Developer CD Series 2000 November: Tool Chest/Dev.CD Nov 00 TC Disk 1.toast/Sample Code/Contributed/SpriteWorld/SpriteWorld Examples/Scrolling - Multiple Layers/Multiple Layers Demo.c

C/C++ Source or Header | 2000-10-06 | 22.4 KB | 796 lines | [TEXT/CWIE]

///--------------------------------------------------------------------------------------
// Multiple Layers Demo.c
//
// By Vern Jensen. Just a slightly modified version of the Scrolling Demo.
///--------------------------------------------------------------------------------------
#ifndef __RESOURCES__
#include <Resources.h>
#endif


#include <SWFPSReport.h>
#include <SWIncludes.h>
#include <SWGameUtils.h>

#include "SWApplication.h"
#include "Multiple Layers Demo.h"


#define    kFullScreenWindow            true        // Makes window larger than 512x384.
#define kDoubleSize                    true        // Doubles size of extraBackFrameP
#define kWorldRectInset                0            // Make the SpriteWorld smaller?
#define    kInterlacedMode                false        // Skips every other line
#define kSyncToVBL                    false        // Sync SpriteWorld to VBL?
#define kMaxFPS                        30            // Set to 0 for unrestricted speed

#define kMaxWidth                    640            // max window width in full-screen mode
#define kMaxHeight                    480            // max window height

#define    kSpriteMoveDelta            20            // Try 5, 10, 20, or 40
#define kDiamondSpace                8            // How far apart the diamonds are spaced
                                                // (try 1!)

#define kSpriteMoveDistance            80            // How far the sprite can move from
                                                // the center of the screen, in pixels.
                                                // Try making this value higher!

    // Number of ticks to wait before changing tile image; 0 = change every frame
#define kDiamondFrameRate            8            // How often diamond tiles change frames
#define kWallFrameRate                120            // How often wall changes frames

#define kBWPictResIDOffset            100
#define kTileWidth                    40
#define kTileHeight                    40
#define kTileMapRows                100
#define kTileMapCols                150

#define kStartRow                    5            // Starting position of sprite
#define kStartCol                    5            // in tile col and row


#define    kLeftArrowKey                0x7B
#define    kRightArrowKey                0x7C
#define    kDownArrowKey                0x7D
#define    kUpArrowKey                    0x7E

#define    kLeftKeyPad                    0x56
#define    kRightKeyPad                0x58
#define    kDownKeyPad                    0x54
#define    kUpKeyPad                    0x5B

#define kEscKey                        0x35


#define kNoKey                        0
#define kLeftKey                    1
#define kUpKey                        2
#define kRightKey                    3
#define kDownKey                    4


enum tileIDs
{
    kWallTile,
    kLastWallTile,
    kGrassTile,
    kBlackTile,
    kFirstDiamondTile,
    kMiddleDiamondTile,
    kLastDiamondTile,
    kWireTile,

    kMaxNumTiles
};



/***********/
/* Globals */
/***********/

SpriteWorldPtr        gSpriteWorldP;
SpriteLayerPtr        gSpriteLayerP, gNonScrollingSpriteLayerP;
TileMapStructPtr    gTileMapStructP, gSecondTileMapStructP;
TileMapPtr            gTileMap;
SpritePtr            gSimpleSpriteP, gDiamondMeterSpriteP;
DrawProcPtr            gSpriteDrawProc;
WindowPtr            gWindowP;
Rect                gScreenMidRect;

long                gNumDiamondsInMap = 0;    // Number of diamonds in the TileMap
long                gNumDiamonds = 0;        // Number of diamonds sprite has collected

struct moveKeys        // Keeps track of which keys are up and which are down
{
    Boolean    up;
    Boolean    right;
    Boolean    down;
    Boolean    left;
} gKeys;


///--------------------------------------------------------------------------------------
// Main
///--------------------------------------------------------------------------------------

void    main( void )
{
    Initialize(kNumberOfMoreMastersCalls);

    if (SWHasSystem7())
    {
        AllowKeyUpEvents();    // Part of SWGameUtils.c
        SetCursor(*GetCursor(watchCursor));
        HideControlStrip();

        SWSetCleanUpFunction(MyCleanUpFunction);

        CreateSpriteWorld();
        SetUpTiling();
        CreateBallSprite();
        CreateDiamondMeterSprite();

        SetCursor(&qd.arrow);
        HideCursor();

        SetUpAnimation();
        RunAnimation();
        ShutDown();

        RestoreControlStrip();    // Call this after using HideControlStrip before quitting
        RestoreEventMask();        // Call this after using AllowKeyUpEvents before quitting
    }
    else
    {
        CantRunOnThisMachine();
    }
}


///--------------------------------------------------------------------------------------
// CreateSpriteWorld
///--------------------------------------------------------------------------------------

void    CreateSpriteWorld( void )
{
    Rect        offscreenRect, worldRect, windRect;
    RgnHandle    mBarUpdateRgn;
    OSErr        err;

    gWindowP = GetNewCWindow(kWindowResID, NULL, (WindowPtr)-1L);

    if (gWindowP != NULL)
    {
        if (kFullScreenWindow == true)
        {
            SizeWindow(gWindowP, SW_MIN(qd.screenBits.bounds.right, kMaxWidth),
                    SW_MIN(qd.screenBits.bounds.bottom, kMaxHeight), false);
            MoveWindow(gWindowP, 0, 0, false);
        }

            // Center window in screen
        windRect = gWindowP->portRect;
        CenterRect(&windRect, &qd.screenBits.bounds);

            // Make sure window is aligned to long-word boundaries (for 8-bit mode)
        windRect.left = windRect.left>>2<<2;

        MoveWindow(gWindowP, windRect.left, windRect.top, false);

        ShowWindow(gWindowP);
        SetPort(gWindowP);
        mBarUpdateRgn = SWHideMenuBar(gWindowP); // Must be done *after* showing window!
        EraseRgn(mBarUpdateRgn);

        if (kInterlacedMode)
            PaintRect(&gWindowP->portRect);    // Blacken window for Interlaced mode
    }
    else
        CantFindResource();


    err = SWEnterSpriteWorld();
    FatalError(err);


    worldRect = gWindowP->portRect;
    InsetRect(&worldRect, kWorldRectInset, kWorldRectInset);


        // Set size of offscreen area
    offscreenRect = worldRect;
    OffsetRect(&offscreenRect, -offscreenRect.left, -offscreenRect.top);


        // Make offscreen area evenly divisible by tile width & height
    if ( (offscreenRect.right/kTileWidth)*kTileWidth != offscreenRect.right)
        offscreenRect.right = (offscreenRect.right/kTileWidth)*kTileWidth + kTileWidth;

    if ( (offscreenRect.bottom/kTileHeight)*kTileHeight != offscreenRect.bottom)
        offscreenRect.bottom = (offscreenRect.bottom/kTileHeight)*kTileHeight + kTileHeight;

        // Create the scrolling sprite world
    err = SWCreateSpriteWorldFromWindow(&gSpriteWorldP, (CWindowPtr)gWindowP,
            &worldRect, &offscreenRect, 0);
    FatalError(err);

        // Create the sprite layers
    err = SWCreateSpriteLayer(&gSpriteLayerP);
    FatalError(err);
    err = SWCreateSpriteLayer(&gNonScrollingSpriteLayerP);
    FatalError(err);

        // Add them to the world
    SWAddSpriteLayer(gSpriteWorldP, gSpriteLayerP);                    // Bottom
    SWAddSpriteLayer(gSpriteWorldP, gNonScrollingSpriteLayerP);        // Top


    gSpriteDrawProc = SWStdSpriteDrawProc;

        // Determine what DrawProcs to use
    if (gSpriteWorldP->pixelDepth >= 8)        // 8-bit, 16-bit, or 32-bit, for 68k and PPC
    {
        gSpriteDrawProc = BlitPixieMaskDrawProc;
        SWSetSpriteWorldOffscreenDrawProc(gSpriteWorldP, BlitPixieRectDrawProc);
        SWSetDoubleRectDrawProc(gSpriteWorldP, BlitPixieDoubleRectDrawProc);
        SWSetPartialMaskDrawProc(gSpriteWorldP, BlitPixiePartialMaskDrawProc);
    }
    else if (SW_68K)    // Use AllBit blitters when in depths lower than 8-bits on 68k.
    {
        gSpriteDrawProc = BlitPixieAllBitMaskDrawProc;
        SWSetSpriteWorldScreenDrawProc(gSpriteWorldP, BlitPixieAllBitRectDrawProc);
        SWSetSpriteWorldOffscreenDrawProc(gSpriteWorldP, BlitPixieAllBitRectDrawProc);
        SWSetPartialMaskDrawProc(gSpriteWorldP, BlitPixieAllBitPartialMaskDrawProc);
    }
}


///--------------------------------------------------------------------------------------
// SetUpTiling
///--------------------------------------------------------------------------------------

void    SetUpTiling( void )
{
    TileMapPtr        tileMap;
    short            row, col;
    OSErr            err;

    err = SWInitTiling(gSpriteWorldP, kTileHeight, kTileWidth, kMaxNumTiles);
    FatalError(err);

    err = SWCreateTileMap(&gTileMapStructP, kTileMapRows, kTileMapCols);
    FatalError(err);

    SWInstallTileMap(gSpriteWorldP, gTileMapStructP, 0);
    gTileMap = gTileMapStructP->tileMap;

        // Load first set of tiles
    err = SWLoadTilesFromPictResource(
        gSpriteWorldP,
        kWallTile,                // startTileID
        kBlackTile,                // endTileID
        200,                    // pictResID
        0,                        // maskResID
        kNoMask,                // maskType
        kMaskIsNotPartialMask,    // partialMask?
        0,                        // horizBorderWidth
        0);                        // vertBorderHeight
    FatalError(err);

        // Load self-masked diamond tiles
    err = SWLoadTilesFromPictResource(
        gSpriteWorldP,
        kFirstDiamondTile,        // startTileID
        kLastDiamondTile,        // endTileID
        201,                    // pictResID
        201,                    // maskResID (same as pictResID)
        kFatMask,                // maskType
        kMaskIsNotPartialMask,    // partialMask?
        0,                        // horizBorderWidth
        0);                        // vertBorderHeight
    FatalError(err);

        // Load the wire tile
    err = SWLoadTileFromCicnResource(
        gSpriteWorldP,
        kWireTile,                // tileID
        131,                     // CICN resource ID
        kFatMask,                // maskType
        kMaskIsNotPartialMask);    // partialMask?
    FatalError(err);


        // Set up tileMap
    for (row = 0; row < kTileMapRows; row++)
    {
        for (col = 0; col < kTileMapCols; col++)
        {
            if (row == 0 || col == 0 || row == kTileMapRows-1 || col == kTileMapCols-1)
                gTileMap[row][col] = kWallTile;
            else if (row > kTileMapRows / 2)
                gTileMap[row][col] = -1;
            else if ((row/kDiamondSpace)*kDiamondSpace == row &&
                     (col/kDiamondSpace)*kDiamondSpace == col)
            {
                gTileMap[row][col] = kFirstDiamondTile;
                gNumDiamondsInMap++;
            }
            else
                gTileMap[row][col] = kGrassTile;
        }
    }



        // Create the second tileMap
    err = SWCreateTileMap(&gSecondTileMapStructP, kTileMapRows, kTileMapCols);
    FatalError(err);

    SWInstallTileMap(gSpriteWorldP, gSecondTileMapStructP, 1);
    tileMap = gSecondTileMapStructP->tileMap;

        // Set up tileMap
    for (row = 0; row < kTileMapRows; row++)
    {
        for (col = 0; col < kTileMapCols; col++)
        {
            if (col > kTileMapCols / 2)
                tileMap[row][col] = kWireTile;
            else
                tileMap[row][col] = -1;
        }
    }
}


///--------------------------------------------------------------------------------------
// CreateBallSprite
///--------------------------------------------------------------------------------------

void    CreateBallSprite( void )
{
    OSErr    err;

        // Create the ball sprite
    err = SWCreateSpriteFromCicnResource(gSpriteWorldP, &gSimpleSpriteP, NULL,
            129, 1, kFatMask);
    FatalError(err);

        // Set up the ball sprite
    SWAddSprite(gSpriteLayerP, gSimpleSpriteP);
    SWSetSpriteMoveProc(gSimpleSpriteP, KeySpriteMoveProc);
    SWSetSpriteLocation(gSimpleSpriteP, kStartCol * kTileWidth, kStartRow * kTileHeight);
    SWSetSpriteMoveDelta(gSimpleSpriteP, 0, 0);
    SWSetSpriteDrawProc(gSimpleSpriteP, gSpriteDrawProc);
}


///--------------------------------------------------------------------------------------
// CreateDiamondMeterSprite
///--------------------------------------------------------------------------------------

void    CreateDiamondMeterSprite( void )
{
    OSErr        err;

        // Create the diamond meter sprite
    err = SWCreateSpriteFromPictResource(gSpriteWorldP,
                &gDiamondMeterSpriteP,
                NULL,            // pointer to memory for sprite
                202,             // picture resource id
                202,            // mask resource id
                1,                 // max frames
                kFatMask);        // mask type
    FatalError(err);

    SWAddSprite(gNonScrollingSpriteLayerP, gDiamondMeterSpriteP);
    SWSetSpriteDrawProc(gDiamondMeterSpriteP, gSpriteDrawProc);
    SWSetSpriteMoveProc(gDiamondMeterSpriteP, DiamondMeterSpriteMoveProc);
    SWSetSpriteLocation(gDiamondMeterSpriteP, 10, 10);

        // Mark this layer as a non-scrolling layer
    SWSetLayerAsNonScrolling(gNonScrollingSpriteLayerP, true);
}


///--------------------------------------------------------------------------------------
// SetUpAnimation
///--------------------------------------------------------------------------------------

void    SetUpAnimation( void )
{
    Rect        moveBoundsRect, extraBackRect;
    short        row, col;
    PicHandle    backPictH;
    OSErr        err;

    SWLockSpriteWorld(gSpriteWorldP);

        // Set up data used by the SmoothScrollingWorldMoveProc
    gScreenMidRect = gSimpleSpriteP->curFrameP->frameRect;
    CenterRect( &gScreenMidRect, &gSpriteWorldP->backRect );

    SWSetSpriteWorldMaxFPS(gSpriteWorldP, kMaxFPS);
    SWSyncSpriteWorldToVBL(gSpriteWorldP, kSyncToVBL);
    SWSetCleanUpSpriteWorld(gSpriteWorldP);

        // movement boundary = size of tileMap
    SetRect(&moveBoundsRect, 0,0, kTileMapCols * kTileWidth, kTileMapRows * kTileHeight);

    SWSetScrollingWorldMoveBounds(gSpriteWorldP, &moveBoundsRect);
    SWSetScrollingWorldMoveProc(gSpriteWorldP, SmoothScrollingWorldMoveProc, gSimpleSpriteP);

    SWSetSpriteLayerUnderTileLayer(gSpriteLayerP, 1);
    SWSetTileChangeProc(gSpriteWorldP, TileChangeProc);

        // Move visScrollRect to starting sprite position
    SWMoveVisScrollRect(gSpriteWorldP,
        gSpriteWorldP->followSpriteP->destFrameRect.left - gSpriteWorldP->backRect.right/2,
        gSpriteWorldP->followSpriteP->destFrameRect.top - gSpriteWorldP->backRect.bottom/2);

        // Set starting position of diamond meter sprite
    DiamondMeterSpriteMoveProc(gDiamondMeterSpriteP);

    SWSetTileMaskDrawProc(gSpriteWorldP, gSpriteDrawProc);

    if (kInterlacedMode)
    {
        SWSetFrameInterlacingMode(gSpriteWorldP->workFrameP, true, kSkipOddLines);
        SWSetFrameInterlacingMode(gSpriteWorldP->windowFrameP, true, kSkipOddLines);

        SWSetPortToWorkArea(gSpriteWorldP);
        PaintRect(&gSpriteWorldP->backRect);
    }

        // Make sure CopyBits, if used, doesn't try to colorize things
    SWSetPortToWindow(gSpriteWorldP);
    ForeColor(blackColor);
    BackColor(whiteColor);

    backPictH = GetPicture(128);    // Color pict

    if (backPictH == nil)
        FatalError(-1);

    extraBackRect = (**(backPictH)).picFrame;

    if (kDoubleSize)
    {
        extraBackRect.right *= 2;
        extraBackRect.bottom *= 2;
    }

    err = SWCreateExtraBackFrame(gSpriteWorldP, &extraBackRect);
    FatalError(err);
    SWLockFrame(gSpriteWorldP->extraBackFrameP);
    SWSetPortToExtraBackFrame(gSpriteWorldP);
    DrawPicture(backPictH, &extraBackRect);
    ReleaseResource((Handle)backPictH);

        // Erase the tile directly beneath the Sprite's starting position
    row = gSimpleSpriteP->destFrameRect.top / kTileHeight;
    col = gSimpleSpriteP->destFrameRect.left / kTileWidth;
    gTileMap[row][col] = -1;

    SWDrawTilesInBackground(gSpriteWorldP);
    SWUpdateScrollingSpriteWorld(gSpriteWorldP, true);
}


///--------------------------------------------------------------------------------------
//  RunAnimation
///--------------------------------------------------------------------------------------

void    RunAnimation( void )
{
    unsigned long        frames;

    frames = 0;
    StartTimer();


    while (!Button())
    {
        SWProcessScrollingSpriteWorld(gSpriteWorldP);
        SWAnimateScrollingSpriteWorld(gSpriteWorldP);

        if (gSpriteWorldP->frameHasOccurred)
            frames++;
    }

    SWShowMenuBar(gWindowP);
    ShowResults(frames);
}


///--------------------------------------------------------------------------------------
//  ShutDown (clean up and dispose of the SpriteWorld)
///--------------------------------------------------------------------------------------

void    ShutDown( void )
{
    SWDisposeSpriteWorld(&gSpriteWorldP);
    SWDisposeTileMap(&gTileMapStructP);            // SWDisposeSpriteWorld will not
    SWDisposeTileMap(&gSecondTileMapStructP);    // dispose our TileMaps for us.
    SWExitSpriteWorld();

    FlushEvents(everyEvent, 0);
    InitCursor();
}


///--------------------------------------------------------------------------------------
//  MyCleanUpFunction - called if an error occurs, to clean up before quitting
///--------------------------------------------------------------------------------------

void    MyCleanUpFunction( void )
{
    SWShowMenuBar(gWindowP);

    RestoreControlStrip();
    RestoreEventMask();
}


#pragma mark -
///--------------------------------------------------------------------------------------
//  TileChangeProc
///--------------------------------------------------------------------------------------

SW_FUNC void TileChangeProc(
    SpriteWorldPtr spriteWorldP)
{
    short            curImage;
    static short    wallDelay = 0, diamondDelay = 0;
    static short    oldTicks = 0;
    short            ticksPassed, ticks;

        // Initialize oldTicks the first time this function is called
    if (oldTicks == 0)
        oldTicks = TickCount();

    ticks = TickCount();
    ticksPassed = ticks - oldTicks;        // Number of ticks passed since last call
    oldTicks = ticks;

        // kWallTile
    wallDelay += ticksPassed;
    if (wallDelay >= kWallFrameRate)
    {
        curImage = spriteWorldP->curTileImage[kWallTile];
        if (curImage < kLastWallTile)
            curImage++;
        else
            curImage = kWallTile;

        SWChangeTileImage(spriteWorldP, kWallTile, curImage);
        wallDelay = 0;
    }


        // kDiamondTile
    diamondDelay += ticksPassed;
    if (diamondDelay >= kDiamondFrameRate)
    {
        curImage = spriteWorldP->curTileImage[kFirstDiamondTile];
        if (curImage < kLastDiamondTile)
            curImage++;
        else
            curImage = kFirstDiamondTile;

        SWChangeTileImage(spriteWorldP, kFirstDiamondTile, curImage);
        diamondDelay = 0;
    }
}


///--------------------------------------------------------------------------------------
//  KeySpriteMoveProc
///--------------------------------------------------------------------------------------

SW_FUNC void KeySpriteMoveProc(SpritePtr srcSpriteP)
{
    short        row, col;
    short        rowDelta, colDelta;
    short        tile;

    UpdateKeys();    // Put the latest key values in the keys structure


    row = SWGetSpriteVertLoc(srcSpriteP) / kTileHeight;
    col = SWGetSpriteHorizLoc(srcSpriteP) / kTileWidth;

    if (row * kTileHeight == SWGetSpriteVertLoc(srcSpriteP) &&
        col * kTileWidth == SWGetSpriteHorizLoc(srcSpriteP))
    {
        rowDelta = 0;
        colDelta = 0;

        if (gKeys.left)
            colDelta = -1;
        else if (gKeys.right)
            colDelta = 1;
        else if (gKeys.up)
            rowDelta = -1;
        else if (gKeys.down)
            rowDelta = 1;

        tile = gTileMap[row + rowDelta][col + colDelta];

        if (tile != kWallTile)
        {
            srcSpriteP->vertMoveDelta = rowDelta * kSpriteMoveDelta;
            srcSpriteP->horizMoveDelta = colDelta * kSpriteMoveDelta;
        }
        else
        {
            srcSpriteP->vertMoveDelta = 0;
            srcSpriteP->horizMoveDelta = 0;
        }
    }

    if (srcSpriteP->vertMoveDelta || srcSpriteP->horizMoveDelta)
    {
        SWOffsetSprite(srcSpriteP, srcSpriteP->horizMoveDelta, srcSpriteP->vertMoveDelta);

            // Determine if the sprite is completely within the grid after moving
        row = SWGetSpriteVertLoc(srcSpriteP) / kTileHeight;
        col = SWGetSpriteHorizLoc(srcSpriteP) / kTileWidth;

        if (row * kTileHeight == SWGetSpriteVertLoc(srcSpriteP) &&
            col * kTileWidth == SWGetSpriteHorizLoc(srcSpriteP))
        {
                // We're aligned with the grid, so do things normally
            tile = gTileMap[row][col];

                // Leave black trail behind sprite
            if (tile == kGrassTile || tile == kFirstDiamondTile)
                SWDrawTile(gSpriteWorldP, 0, row, col, -1);    // kBlackTile

            if (tile == kFirstDiamondTile)
            {
                gNumDiamonds++;            // Increase number of diamonds sprite has collected
                UpdateDiamondMeter();    // Update meter
            }
        }
        else
        {
                // We're not aligned with the grid, so erase the piece of grass
                // tile the Sprite has just moved over, if it just ran over some grass.
            if (srcSpriteP->horizMoveDelta > 0)
                col++;
            else if (srcSpriteP->vertMoveDelta > 0)
                row++;

            if (gTileMap[row][col] == kGrassTile)
            {
                gTileMap[row][col] = -1;

                    // I'm breaking a rule here by calling an undocumented function.
                    // It is not recommended that you do this in your own code, but is
                    // necessary in this case for the effect I want to achieve.
                (*gSpriteWorldP->tileRectDrawProc)(gSpriteWorldP, &srcSpriteP->destFrameRect, false);
                SWWrapRectToWorkArea(gSpriteWorldP, &srcSpriteP->destFrameRect);
                gTileMap[row][col] = kGrassTile;
            }
        }
    }
}


///--------------------------------------------------------------------------------------
//  DiamondMeterSpriteMoveProc - not installed as a MoveProc, but called directly
///--------------------------------------------------------------------------------------

SW_FUNC void DiamondMeterSpriteMoveProc(SpritePtr srcSpriteP)
{
        // Move sprite to top-left corner of current visScrollRect location
    SWMoveSprite(srcSpriteP,
        gSpriteWorldP->visScrollRect.left + 10,
        gSpriteWorldP->visScrollRect.top + 10);
}


///--------------------------------------------------------------------------------------
//  UpdateDiamondMeter - change the meter Sprite's image and mask
///--------------------------------------------------------------------------------------

SW_FUNC void UpdateDiamondMeter( void )
{
    double    percent;
    Rect    meterRect;

    percent = (double)gNumDiamonds / gNumDiamondsInMap;

        // 108 = length of meter; 17 = offset from start of meter
    SetRect(&meterRect, 17, 2, (108 * percent) + 17, 14);


        // Set port to our sprite's framePort GWorld
    SetGWorld(gDiamondMeterSpriteP->curFrameP->framePort, nil);

    ForeColor(magentaColor);
    PaintRect(&meterRect);

        // IMPORTANT: Set the color back when done! (In case CopyBits is used later)
    ForeColor(blackColor);


        // Update the pixel mask directly if we are using a pixelMask.
    if (gDiamondMeterSpriteP->frameDrawProc != SWStdSpriteDrawProc)
    {
            // Set port to our sprite's pixel mask GWorld
        SetGWorld(gDiamondMeterSpriteP->curFrameP->maskPort, nil);

            // Mask image is inverted when in 8-bit or less
        if (gSpriteWorldP->pixelDepth <= 8)
            ForeColor(whiteColor);
        else
            ForeColor(blackColor);

        PaintRect(&meterRect);
        ForeColor(blackColor);
    }
    else
    {
            // Otherwise, use SWUpdateFrameMasks to update the region mask.
        SWUpdateFrameMasks(gDiamondMeterSpriteP->curFrameP);
    }


        // Set sprite to be redrawn, since we've changed its image
    gDiamondMeterSpriteP->needsToBeDrawn = true;
}


///--------------------------------------------------------------------------------------
//  SmoothScrollingWorldMoveProc - our scrolling WorldMoveProc
///--------------------------------------------------------------------------------------

SW_FUNC void SmoothScrollingWorldMoveProc(
    SpriteWorldPtr spriteWorldP,
    SpritePtr followSpriteP)
{
    short    screenMidRectTop, screenMidRectLeft;

    screenMidRectTop = gScreenMidRect.top + spriteWorldP->visScrollRect.top;
    screenMidRectLeft = gScreenMidRect.left + spriteWorldP->visScrollRect.left;


    spriteWorldP->horizScrollDelta = (kSpriteMoveDelta *
        (SWGetSpriteHorizLoc(followSpriteP) - screenMidRectLeft) ) / kSpriteMoveDistance;

    spriteWorldP->vertScrollDelta = (kSpriteMoveDelta *
        (SWGetSpriteVertLoc(followSpriteP) - screenMidRectTop) ) / kSpriteMoveDistance;

    if (kInterlacedMode)
        spriteWorldP->vertScrollDelta = spriteWorldP->vertScrollDelta>>1<<1;
}


///--------------------------------------------------------------------------------------
//  UpdateKeys (Put the latest key values in the keys structure)
///--------------------------------------------------------------------------------------

void    UpdateKeys( void )
{
    EventRecord        event;
    short            theKey;
    Boolean            isDown;

    while ( GetOSEvent( (keyUpMask | keyDownMask), &event ) )
    {
        theKey = (event.message & keyCodeMask) >> 8;
        isDown = (event.what != keyUp);

        if ( (theKey == kLeftArrowKey) || (theKey == kLeftKeyPad) )
            gKeys.left = isDown;
        else if ( (theKey == kRightArrowKey) || (theKey == kRightKeyPad) )
            gKeys.right = isDown;
        else if ( (theKey == kDownArrowKey) || (theKey == kDownKeyPad) )
            gKeys.down = isDown;
        else if ( (theKey == kUpArrowKey) || (theKey == kUpKeyPad) )
            gKeys.up = isDown;
    }
}